const maxHCnt = 4;
const maxWCnt = 4;
const dirArr =[{i:-1,j:0},{i:1,j:0},{i:0,j:-1},{i:0,j:1}] //方向数组 二维数组 基于mapArr
//要生成一个4*4的地图

//1.生成一个基础随机数组
//2.根据基础随机数组将其连通 
//3.将地图剩余的位置随机生成类型


function randomBaseArr(){
    let mapCount = 8; //要连通的地图有8块
    let mapArr =[];
    //对地图进行初始化，0代表没有地图块，1代表有地图块
    for(let i =0;i<maxHCnt;i++){
         mapArr[i] = [];
        for(let j = 0;j<maxHCnt;j++){
            mapArr[i][j] = 0;
        }
    }
    //随机出地图的起点
    let startPosX =parseInt(Math.random()*maxWCnt);
    let startPosY =parseInt(Math.random()*maxHCnt);
    let startPos ={i:startPosX,j:startPosY};

    //找到起始点随机地图块周围的地图块
    let nextArr = setMap(mapArr,startPos);
    mapCount --;
  
    //从周围的地图块在随机一块地图块处理 这是一个循环
    //只有mapArr的
    while(mapCount&&nextArr.length>0){

     let randomIndex =  parseInt(Math.random()*nextArr.length);
    let nextPos =  nextArr.splice(randomIndex,1)[0];

    //在对nextPos找通路，和nextArr重复
    let nearArr = setMap(mapArr,nextPos);

    //如果有返回，则成功设置了一块
    if(nearArr){
       
        mapCount --;
        nextArr = dedupArr([...nearArr,...nextArr]);
    }
    }
    return {mapArr,startPos};

    
}

//目的是根据mapArr 从找出的通路，连通通路，并把这些通路连通  
function getRandomMapName(){

    let {mapArr,startPos} = randomBaseArr();
    
    let mapNameArr = [];

    for (let i = 0; i < mapArr.length; i++) {
        mapNameArr[i] = [];
        for(let j = 0;j<mapArr[i].length;j++){
            mapNameArr[i][j] = '00000';
        }
    }

    for (let i = 0; i < mapArr.length; i++) {
        for(let j = 0;j<mapArr[i].length;j++){

            if(!mapArr[i][j])continue;
                //如果这个地图块被标记后，在其四周看看有没有被标记的地图块，将两块进行连通
                 for(let m = 0;m<dirArr.length;m++){
                    // 
                    //  let x = i+dirArr[m].i;
                    //  let y =j+dirArr[m].j;
                    //  let nearBlock = {i:x,j:y}

                    //  
                    //  let nowBlock = {i:i,j:j};
                     
                        connectBlock(mapNameArr,m,{i,j})
                    
                 
            }
        }
        
    }
    

    //随机连接地图
    randomEmptyMap(mapNameArr);

    return mapNameArr;

}

// nowBlock 当前遍历的块 在mapArr中的位置 第几行第几列 i，j
//mapNameArr 地图类型结果数组 目的是对这个数组进行设置
//dirNum 当前块和 相邻块的方向索引  dirArr方向数组的索引
//dirNotNull 当前块和相邻块（是个‘0000’）是否允许当前块连过去 true不允许连过去，false允许连过去
function connectBlock(mapNameArr,dirNum,nowBlock,dirNotNull = false){
    //
   
    // if(!mapNameArr[nowBlock.i][nowBlock.j])return;
    let nearBlockX = nowBlock.i + dirArr[dirNum].i;
    let nearBlockY = nowBlock.j + dirArr[dirNum].j;
    //越界return
    if(nearBlockX < 0||nearBlockX>=maxWCnt||nearBlockY<0||nearBlockY>=maxHCnt)return;

    //如果遇到全空的‘00000’类型地图不允许连过去 
    if(dirNotNull&&mapNameArr[nearBlockX][nearBlockY] =='00000')return;
    
    // 

    let nowBlockName = mapNameArr[nowBlock.i][nowBlock.j].split('');
    let nearBlockName = mapNameArr[nearBlockX][nearBlockY].split('');

    nowBlockName[dirNum] ='1';
    if(dirNum == 0){ //上
        nearBlockName[1] = '1';
    }else if(dirNum == 1){ //下
        nearBlockName[0] = '1';
    }else if(dirNum == 2){ //左
        nearBlockName[3] = '1';
    }else  if(dirNum == 3){ //右
        nearBlockName[2] = '1';
    }
    nowBlockName = nowBlockName.join('');
    nearBlockName = nearBlockName.join('');

mapNameArr[nowBlock.i][nowBlock.j] = nowBlockName;
mapNameArr[nearBlockX][nearBlockY] = nearBlockName;

}

 function randomEmptyMap(mapNameArr){
     
    console.log('mapNameArr',mapNameArr)
    for(let i =0;i<this.maxHCnt;i<0){
        for(let j =0;j<this.maxWCnt;j++){

            let mapName = mapNameArr[i][j];
            if(mapName!=='00000')continue;

            let dirNum = parseInt(Math.random()*dirArr.length);
            connectBlock(mapNameArr,dirNum,{i,j},true)
        }
    }
}


// function setNextArr(arr,startPos){
//     
// //arr 是一个二维数组
//  let resArr = [];
//  for (let i = 0; i < dirArr.length; i++) {
//     let x = dirArr[i].i+startPos.i;
//     let y = dirArr[i].j+startPos.j;
    
//     //找周围地图块的时候容易越界 且在mapArr被标记为1的不能push到数组中
//     if(x >= maxWCnt||x< 0||y>=maxHCnt||y<0||arr[x][y])continue;
//     resArr.push({i:x,j:y})
 
//  }
//  return resArr;
// }

function setMap(mapArr,index){
    //对随机出的起点可能越界
    if(index.i < 0|| index.i> maxWCnt||index.j<0||index.j>=maxHCnt){
        return null;
    }
    //随机出的点在地图中已经被标记 设置过了
    if(mapArr[index.i][index.j]){
        return null;
    }
     //对点进行标记
     mapArr[index.i][index.j] = 1;

    let nearArr = [];
     //找出这个点周围的点
      for (let i = 0; i < dirArr.length; i++) {
    let x = dirArr[i].i+index.i;
    let y = dirArr[i].j+index.j;
    
    //找周围地图块的时候容易越界 且在mapArr被标记为1的不能push到数组中
    if(x >= maxWCnt||x< 0||y>=maxHCnt||y<0||mapArr[x][y])continue;
    nearArr.push({i:x,j:y})
 
 }
 return nearArr;


}


function dedupArr(arr){

    let resArr = [];

    for (let i = 0; i <arr.length; i++) {
        const element = arr[i];
       let flag = resArr.findIndex((item)=>{
           return item.i==arr[i].i&&item.j==arr[i].j
        })
        //flag 不等于-1证明找到了重复的，不进行push操作
        if(flag!==-1){
            
            continue;
        }
        resArr.push(arr[i]);
    }
    return resArr;
}

// let res  = getRandomMapName();
// console.log('res',res)




 export default{
    getRandomMapName,
 }